package com.mujin.keji.collectionsystem.module.login.syncData;

import android.arch.lifecycle.MutableLiveData;
import android.arch.lifecycle.Observer;
import android.arch.lifecycle.ViewModelProviders;
import android.content.Context;
import android.os.Environment;
import android.os.Message;
import android.support.annotation.NonNull;
import android.util.Log;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.mujin.keji.collectionsystem.Constant;
import com.mujin.keji.collectionsystem.base.BaseVo;
import com.mujin.keji.collectionsystem.common.EmailSituationEnum;
import com.mujin.keji.collectionsystem.common.HouseApplianceEnum;
import com.mujin.keji.collectionsystem.common.InnerDecorationEnum;
import com.mujin.keji.collectionsystem.common.LivingSituationEnum;
import com.mujin.keji.collectionsystem.common.RepayPowerEnum;
import com.mujin.keji.collectionsystem.common.VisitHouseEnum;
import com.mujin.keji.collectionsystem.common.VisitStatusEnum;
import com.mujin.keji.collectionsystem.db.dao.VisitDao;
import com.mujin.keji.collectionsystem.db.database.AppDataBase;
import com.mujin.keji.collectionsystem.db.domain.SaveVisitRecordBean;
import com.mujin.keji.collectionsystem.db.domain.VisitApplyBean;
import com.mujin.keji.collectionsystem.db.domain.VisitApplyDetailBean;
import com.mujin.keji.collectionsystem.db.domain.VisitApplyMarkBean;
import com.mujin.keji.collectionsystem.db.domain.VisitCountBean;
import com.mujin.keji.collectionsystem.dto.VisitCaseDTO;
import com.mujin.keji.collectionsystem.http.HttpUtils;
import com.mujin.keji.collectionsystem.module.login.views.LoginActivity;
import com.mujin.keji.collectionsystem.module.main.views.MainActivity;
import com.mujin.keji.collectionsystem.module.outboundtask.viewmodel.PhotoViewModel;
import com.mujin.keji.collectionsystem.module.outboundtask.viewmodel.RecordViewModel;
import com.mujin.keji.collectionsystem.module.outboundtask.vo.ApplyMarkVo;
import com.mujin.keji.collectionsystem.module.outboundtask.vo.SaveVisitRecordReq;
import com.mujin.keji.collectionsystem.module.outboundtask.vo.StatusCountVo;
import com.mujin.keji.collectionsystem.module.outboundtask.vo.VisitApplyDetailVo;
import com.mujin.keji.collectionsystem.module.outboundtask.vo.VisitFileVo;
import com.mujin.keji.collectionsystem.module.updata.dto.VisitUserDto;
import com.mujin.keji.collectionsystem.utils.FileUtil;

import org.apache.commons.lang3.StringUtils;

import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import okhttp3.Response;

import static com.alibaba.fastjson.JSON.toJSON;
import static com.mujin.keji.collectionsystem.common.SyncDataMethod.queryApplyCase;
import static com.mujin.keji.collectionsystem.common.SyncDataMethod.queryApplyDetail;
import static com.mujin.keji.collectionsystem.common.SyncDataMethod.queryCount;
import static com.mujin.keji.collectionsystem.common.SyncDataMethod.queryMark;
import static com.mujin.keji.collectionsystem.common.SyncDataMethod.saveRecord;
import static com.mujin.keji.collectionsystem.common.SyncDataMethod.visitUpload;
import static com.mujin.keji.collectionsystem.utils.AssambleReqUtil.assambleReqMap;

public class SyncDataThread extends Thread {

    private static final String TAG ="SyncDataThread" ;
    private Context context;
    private String session;
    private String userName;
    private MainActivity activity;
    private RecordViewModel recordViewModel;
    private PhotoViewModel photoViewModel;
    public SyncDataThread(@NonNull Context context, String session, String userName, MainActivity activity) {
        this.context=context;
        this.session=session;
        this.userName =userName;
        this.activity = activity;
        this.photoViewModel = ViewModelProviders.of(activity).get(PhotoViewModel.class);
        this.recordViewModel = ViewModelProviders.of(activity).get(RecordViewModel.class);
    }

    private static final String LOGGER = "异步获取数据线程";


    @Override
    public void run(){
        //同步数据

        Log.e(TAG, "getVisitCollectionCount: 请求的用户名"+userName );
        //获取外访统计条数
        getVisitCollectionCount(userName);

        filterFinish(userName);

        //获取外访催收列表及外访案件详情
        getVisitCollectionList(userName);

    }

    /**
     *
     */
    private void getVisitCollectionCount(String userName){

        StatusCountVo statusCountVo=new StatusCountVo();
        BaseVo baseVo = assambleReqMap(queryCount,session,null);
        Log.i(LOGGER, "获取外访统计条数，请求报文:"+JSONObject.toJSONString(baseVo));
        try {
            Response response = HttpUtils.post(Constant.Server.ROOT_URL+"route/rest/", JSONObject.toJSONString(baseVo));
            String rtn=response.body().string();
            JSONObject rtnJson= JSON.parseObject((String) rtn);
            Log.i(LOGGER, "获取外访统计条数，返回报文:"+rtnJson.toJSONString());
            JSONArray jSONArrayTemp=(JSONArray) toJSON(rtnJson.get("visit_app_collection_count_response"));
            Iterator jsIt=jSONArrayTemp.iterator();

            //先删除，后添加
            VisitDao visitDao = AppDataBase.getInstance(context).getVisitDao();

            visitDao.deleteVisitListByUserName(VisitStatusEnum.VISIT_JINXINGZHONG.getCode());
            VisitCountBean visitCountBean = new VisitCountBean();
            while(jsIt.hasNext()){

                JSONObject jsonContent=(JSONObject)jsIt.next();

                if(jsonContent.get("status").equals("wancheng")){
                    visitCountBean.setFinish(Integer.parseInt(jsonContent.get("task_count").toString()));
                };
                if(jsonContent.get("status").equals("jinxingzhong")){
                    visitCountBean.setWaitVisit(Integer.parseInt(jsonContent.get("task_count").toString()));
                };
                if(jsonContent.get("status").equals("yiwaifang")){
                    visitCountBean.setVisited(Integer.parseInt(jsonContent.get("task_count").toString()));
                };

            }
            visitCountBean.setUserName(userName);

            VisitCountBean visitCount = visitDao.findVisitCountDetail();
            if(visitCount == null){
                visitDao.addVisitCount(visitCountBean);
            }else{
                visitCountBean.setId(visitCount.getId());
                visitDao.updateVisitCount(visitCountBean);
            }

        }catch(Exception e){
            e.printStackTrace();

        }
    }

    private void filterFinish(String userName){
        try {
            AppDataBase appDataBase = AppDataBase.getInstance(context);

            List<VisitApplyBean> lists = appDataBase.getVisitDao().queryVisitByStatus(VisitStatusEnum.VISIT_YIWAIFANG.getCode(),userName);


            //初始化图片文件数据
            List<File> allFiles = new ArrayList<>();
            File file = new File(Environment.getExternalStorageDirectory() + "/temp" );
            File[] files = file.listFiles();
            for (int j = 0; j < files.length; j++) {
                String name = files[j].getName();
                if (files[j].isDirectory()) {
                    String dirPath = files[j].toString().toLowerCase();
                } else if (files[j].isFile() & name.endsWith(".jpg") || name.endsWith(".png") || name.endsWith(".bmp") || name.endsWith(".gif") || name.endsWith(".jpeg") || name.endsWith(".txt")) {
                    allFiles.add(files[j]);
                }
            }

            Set<Long> applyIds = new HashSet<>();
            if(allFiles != null && allFiles.size() > 0){
                for(File file1 : allFiles){
                    if (file1.getName().endsWith(".txt")) {
                        String visitStr = FileUtil.readJsonFromFile(file1);
                        VisitUserDto visitUserDto = JSONObject.parseObject(visitStr, VisitUserDto.class);
                        applyIds.add(Long.valueOf(visitUserDto.getVisitApplyId()));
                    }
                }
            }
            //初始化录音文件数据
            List<File> fileList = new ArrayList<>();
            File recordFile = new File(Constant.Param.RECORDPATH);
            File[] recordFiles = recordFile.listFiles();
            for (int j = 0; j < recordFiles.length; j++) {
                if (!recordFiles[j].isDirectory()) {
                    fileList.add(recordFiles[j]);
                }
            }
            if(fileList != null && fileList.size() > 0){
                for(File file1 : fileList){
                    if (file1.getName().endsWith(".txt")) {
                        String visitStr = FileUtil.readJsonFromFile(file1);
                        VisitUserDto visitUserDto = JSONObject.parseObject(visitStr, VisitUserDto.class);
                        applyIds.add(Long.valueOf(visitUserDto.getVisitApplyId()));
                    }
                }
            }


            for (VisitApplyBean visitApplyBean: lists) {

                if(applyIds.contains(visitApplyBean.getVisitApplyId())){
                    return;
                }
                Long taskId = visitApplyBean.getTaskId();
                VisitCaseDTO visitCaseDTO = new VisitCaseDTO();
                visitCaseDTO.setTaskId(taskId);
                visitCaseDTO.setStatus(VisitStatusEnum.VISIT_WANCHENG.getCode());
                BaseVo baseVo = assambleReqMap(queryApplyCase,session,visitCaseDTO);
                Log.i(LOGGER, "获取外访催收列表，请求报文:"+JSONObject.toJSONString(baseVo));

                    Response response = HttpUtils.post(Constant.Server.ROOT_URL + "route/rest/", JSONObject.toJSONString(baseVo));
                    JSONObject rtnJson=JSON.parseObject(response.body().string());
                    Log.i(LOGGER, "获取外访催收列表，返回报文:"+rtnJson.toJSONString());
                    if(rtnJson.get("visit_app_apply_query_response") == null){
                        Log.i(LOGGER, "获取外访催收列表，获取数据异常:"+JSONObject.toJSONString(rtnJson.get("error_response")));
                        return;
                    }
                    JSONArray jsonArray=(JSONArray) toJSON(rtnJson.get("visit_app_apply_query_response"));
                    Iterator jsIt=jsonArray.iterator();

                    while(jsIt.hasNext()){
                        VisitApplyBean visitApply = JSONObject.parseObject(JSONObject.toJSONString(jsIt.next()), VisitApplyBean.class);

                        if(VisitStatusEnum.VISIT_WANCHENG.getCode().equals(visitApply.getStatus())){
                            //更新状态
                            visitApplyBean.setStatus(visitApply.getStatus());
                            appDataBase.getVisitDao().updateVisitApply(visitApplyBean);
                        }
                    }


            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }


    /**
     * 获取外访催收列表(全部类型)
     */
    private void getVisitCollectionList(String userName){
        Log.i(LOGGER, "开始获取外访催收列表，session:"+session);
        VisitCaseDTO visitCaseDTO = new VisitCaseDTO();
        visitCaseDTO.setStatus(VisitStatusEnum.VISIT_JINXINGZHONG.getCode());
        BaseVo baseVo = assambleReqMap(queryApplyCase,session,visitCaseDTO);
        Log.i(LOGGER, "获取外访催收列表，请求报文:"+JSONObject.toJSONString(baseVo));
        try {
            Response response = HttpUtils.post(Constant.Server.ROOT_URL+"route/rest/", JSONObject.toJSONString(baseVo));
            JSONObject rtnJson=JSON.parseObject(response.body().string());
            Log.i(LOGGER, "获取外访催收列表，返回报文:"+rtnJson.toJSONString());
            if(rtnJson.get("visit_app_apply_query_response") == null){
                Log.i(LOGGER, "获取外访催收列表，获取数据异常:"+JSONObject.toJSONString(rtnJson.get("error_response")));
                return;
            }
            JSONArray jsonArray=(JSONArray) toJSON(rtnJson.get("visit_app_apply_query_response"));
            Iterator jsIt=jsonArray.iterator();

            AppDataBase appDataBase = AppDataBase.getInstance(context);
            //先删除待外访和已完成数据，然后同步
            appDataBase.getVisitDao().deleteVisitListByUserName(VisitStatusEnum.VISIT_JINXINGZHONG.getCode());

            while(jsIt.hasNext()){

                VisitApplyBean visitApply = JSONObject.parseObject(JSONObject.toJSONString(jsIt.next()), VisitApplyBean.class);

                //先查询本地库有没有,没有->插入，有->新增
                visitApply.setVisitApplyId(visitApply.getId());
                VisitApplyBean bean = appDataBase.getVisitDao().queryVisitList(visitApply.getVisitApplyId());
                visitApply.setUserName(userName);
                if(bean==null){
                    visitApply.setId(null);
                    appDataBase.getVisitDao().addVisitList(visitApply);
                }
                //获取外访案件详情
                getVisitApplyDetail(String.valueOf(visitApply.getTaskId()));

                //获取案件催记
                getCollectionInfo(visitApply.getCaseId());


            }
            activity.getHandler().sendEmptyMessage(3001);
        }catch (Exception e){

            Message message = Message.obtain();
            message.obj = e.getMessage();
            activity.getHandler().sendMessage(message);
            Log.e(LOGGER, "获取外访催收列表异常",e);
        }
    }

    /**
     * 根据外访任务id获取外访案件详情
     * @param taskId
     */
    private void getVisitApplyDetail(String taskId){
        Log.i(LOGGER,"获取外访案件详情，taskId:"+taskId);
        VisitApplyDetailVo detailVo = new VisitApplyDetailVo();
        detailVo.setTaskId(taskId);
        BaseVo baseVo = assambleReqMap(queryApplyDetail,session,detailVo);
        Log.i(LOGGER, "获取外访案件详情，请求报文:"+JSONObject.toJSONString(baseVo));
        try {
            Response response = HttpUtils.post(Constant.Server.ROOT_URL+"route/rest/", JSONObject.toJSONString(baseVo));
            if(response.isSuccessful()){
                String responseStr = response.body().string();
                Log.e(TAG, "getVisitApplyDetail: "+responseStr );
                if(StringUtils.isBlank(responseStr)){
                    Log.e(LOGGER, "获取外访案件详情，返回为空");
                    return;
                }
                JSONObject rtnJson=JSON.parseObject(responseStr);
                Log.i(LOGGER, "获取外访案件详情，返回报文:"+rtnJson.toJSONString());
                JSONObject jsonObject=(JSONObject)rtnJson.get("visit_app_apply_detail_response");
                if(jsonObject==null){
                    Log.e(LOGGER,"获取外访案件详情失败");
                    return;
                }
                VisitApplyDetailBean detail = JSONObject.parseObject(JSONObject.toJSONString(jsonObject), VisitApplyDetailBean.class);
                VisitApplyDetailBean detailBean = AppDataBase.getInstance(context).getVisitDao().queryVisitApplyDetailByCaseCode(detail.getCaseCode());
                if(detailBean==null){
                    Log.i(LOGGER,"本地库没有查询到案件详情，新增记录  案件编号："+detail.getCaseCode());
                    AppDataBase.getInstance(context).getVisitDao().addVisitApplyDetail(detail);
                }else{
                    Log.i(LOGGER,"本地库查询到案件详情，修改记录  案件编号："+detail.getCaseCode());
                    detail.setId(detailBean.getId());
                    AppDataBase.getInstance(context).getVisitDao().updateVisitApplyDetail(detail);
                }
            }
        }catch (Exception e){
            Log.e(LOGGER, "获取外访案件详情异常",e);
        }
    }

    /**
     * 获取案件催记 queryMark
     */
    private void getCollectionInfo(String caseId){
        Log.i(LOGGER,"获取案件催记，caseId:"+caseId);
        ApplyMarkVo markVo = new ApplyMarkVo();
        markVo.setCaseId(Long.valueOf(caseId));
        BaseVo baseVo = assambleReqMap(queryMark,session,markVo);
        Log.i(LOGGER, "获取案件催记，请求报文:"+JSONObject.toJSONString(baseVo));
        try {
            Response response = HttpUtils.post(Constant.Server.ROOT_URL+"route/rest/", JSONObject.toJSONString(baseVo));
            if(response.isSuccessful()){
                String responseStr = response.body().string();
                if(StringUtils.isBlank(responseStr)){
                    Log.e(LOGGER, "获取案件催记，返回为空");
                    return;
                }
                JSONObject rtnJson=JSON.parseObject(responseStr);
                Log.i(LOGGER, "获取案件催记，返回报文:"+rtnJson.toJSONString());
                JSONArray jsonArray=(JSONArray)rtnJson.get("visit_app_mark_query_response");
                if(jsonArray==null || jsonArray.size()<1){
                    Log.e(LOGGER,"获取案件催记为空");
                    return;
                }

                VisitApplyMarkBean visitApplyMark = new VisitApplyMarkBean();
                visitApplyMark.setCaseId(caseId);
                visitApplyMark.setMarkBeanStr(JSONObject.toJSONString(jsonArray));
                VisitApplyMarkBean markBean = AppDataBase.getInstance(context).getVisitDao().queryVisitApplyMarkByCaseId(caseId);
                if(markBean==null){
                    Log.i(LOGGER,"本地库没有查询到案件催记，新增记录  案件id："+caseId);
                    AppDataBase.getInstance(context).getVisitDao().addVisitApplyMark(visitApplyMark);
                }else{
                    Log.i(LOGGER,"本地库查询到案件催记，修改记录  案件id："+caseId);
                    visitApplyMark.setId(markBean.getId());
                    AppDataBase.getInstance(context).getVisitDao().updateVisitApplyMark(visitApplyMark);
                }
            }
        }catch (Exception e){
            Log.e(LOGGER, "获取案件催记异常",e);
        }
    }

    /**
     * TODO 保存外访记录 saveRecord
     * @return
     */
    private int saveVisitRecord(SaveVisitRecordReq saveVisitRecordReq,SaveVisitRecordBean saveVisitRecordBean){
        BaseVo baseVo = assambleReqMap(saveRecord,session,saveVisitRecordReq);
        Log.i(LOGGER, "保存外访记录，请求报文:"+JSONObject.toJSONString(baseVo));
        try {
            Response response = HttpUtils.post(Constant.Server.ROOT_URL+"route/rest/", JSONObject.toJSONString(baseVo));
            if(response.isSuccessful()){
                String responseStr = response.body().string();
                if(StringUtils.isBlank(responseStr)){
                    Log.e(LOGGER, "保存外访记录，接口返回为空");
                    return 0;
                }
                JSONObject rtnJson=JSON.parseObject(responseStr);
                Log.i(LOGGER, "保存外访记录，返回报文:"+rtnJson.toJSONString());
                JSONObject jsonObject=(JSONObject)rtnJson.get("visit_app_record_save_response");
                //删除外访记录
                AppDataBase.getInstance(context).getVisitRecord().delete(saveVisitRecordBean);
            }
        }catch (Exception e){
            Log.e(LOGGER, "获取案件催记异常",e);
        }
        return 0;
    }

    /**
     * TODO 文件批量上传 visitUpload
     */
    private boolean uploadFile(List<VisitFileVo> visitFileVos){
        StringBuffer sb = new StringBuffer();
        sb.append("{\n" +
                "\t\t\"visitApplyId\": 40,\n" +
                "\t\t\"caseId\": \"11\",\n" +
                "\t\t\"uploadWithBase64RequestList\": [\n" +
                "\t\t\t{\n" +
                "\t\t\t\t\"content\": \"iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAgAElEQVR4Xuy9B5gd13Um+NfLOfXr1xEdgO5GJgGQAJgpUqIkiwq2ZcnWWLI19tpj787O7ux4/O3sN2OPk8Ze29rxeG3LeR1liZJIURIzCWaRRM6pAXTO8fXLqfY7595bV");
        sb.append("e91N9ANkmAT7MeviQ716lXduveec/7zn/9oekXXsf669gholmHStWsfbz3iau9Vp13BKeljraequoiqz9ChQ+Mv7WrvUSeg9672nlY3AutHr4/AdY2Ampbm9KYFo4MnNr0s81bXdMv60Iw/0Q5nW2I98vpYdlnTuZZYlHS8+rX1+9rzf0DWk7ZuQK5rXq/+TRpPe+O1rCGoPfOqDRctLkC4BWKmr8A2rf5+1t+xPgLvxQio9WCZ31e7jFX4ZzWnudo7qy2H1VaQ2wa9AmGybv6Vt25AVrIIlvM0VvJew8uvNiC8sa8k9qsyIKY5WBSNW");
        sb.append("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");
        sb.append("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");
        sb.append("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");
        sb.append("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");
        sb.append("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\",\n" +
                "\t\t\t\t\"fileCRC\": \"\",\n" +
                "\t\t\t\t\"fileName\": \"测试图片.png\",\n" +
                "\t\t\t\t\"fileNameExt\": \"png\"\n" +
                "\t\t\t}\n" +
                "\t\t]\n" +
                "\t}");
        VisitFileVo vo = JSONObject.parseObject(sb.toString(),VisitFileVo.class);
        visitFileVos.add(vo);
        BaseVo baseVo = assambleReqMap(visitUpload,session,visitFileVos);
        Log.i(LOGGER, "文件批量上传，请求报文:"+JSONObject.toJSONString(baseVo));
        try {
            Response response = HttpUtils.post(Constant.Server.ROOT_URL+"route/rest/", JSONObject.toJSONString(baseVo));
            if(response.isSuccessful()){
                String responseStr = response.body().string();
                if(StringUtils.isNotBlank(responseStr)){
                    JSONObject rtnJson=JSON.parseObject(responseStr);
                    Log.i(LOGGER, "文件批量上传，返回报文:"+rtnJson.toJSONString());
                    JSONObject jsonObject=(JSONObject)rtnJson.get("visit_app_file_upload_response");
                    if((Boolean) jsonObject.get("data")){
                        Log.i(LOGGER, "文件批量上传成功");
                        return true;
                    }
                }
            }
        }catch (Exception e){
            Log.e(LOGGER, "文件批量上传异常",e);
        }
        return false;
    }
}
